#include<stdio.h>
#include<stdlib.h>
//声明全局变量结构体，并对其起一个别名Asc_o;
typedef struct asc{
    int a;//变量；
    struct asc *next;//用于指向下一个结构体的指针，使其保证链表连续；
}Asc_t;
//声明结构体结束；

//声明全局变量结构体，用于储存链表的参数，并对其起一个别名li；
typedef struct list_par{
    int count;//用于对链表计数；
    Asc_t *head;//用于声明链表头结点的以方便初始化；
}List_t;
//声明结构体结束；

//申请List_t结构体类型的函数；函数名init；该函数主要用于初始化链表参数；
List_t *init()
{
    List_t *list = (List_t *)malloc(sizeof(List_t));//申请List_t结构体类型函数，命名list，分配内存；
    if(list == NULL)
    {
        perror("malloc errror\n");
        free(list);
        return NULL;
    }
    list->count = 0;
    list->head = NULL;
//申请结构体函数；申请Asc_t类型结构体head，并对其进行初始化，该函数主要用于声明头节点，并永远固定指向头节点，方便链表找到头节点地址;
    list->head = (Asc_t *)malloc(sizeof(Asc_t));//申请内存空间；
    if(list->head == NULL)
    {
        perror("malloc error\n");
        free(list->head);
        return NULL;
    }
    list->head->next = NULL;
    return list;
}
//初始化函数结束；

//声明无返回值函数，名字：list_inseert_fail；函数需要List_t结构体函数地址，和需要导入链表整数变量值；
//list是链表参数，a是链表需要储存的值；
void list_insert_fail(List_t *list,int a)
{
    Asc_t *new_init = (Asc_t *)malloc(sizeof(Asc_t));//声明Asc_t结构体函数，名字new_init；申请内存空间，初始化
    if(new_init == NULL)
    {
        perror("malloc error\n");
        free(new_init);
        return ;
    }
    new_init->a = a;
    new_init->next = NULL;
//new_init初始化结束

//判断如果是第一次赋值，head头节点中的next指针指向new_init
    if(list->count == 0)
        list->head->next = new_init;
//否则先声明新的Asc_t结构体指针p指向list->head
    else
    {
        Asc_t *p = list->head;
        while(1)
        {
            //为什么要在无限循环里找p = p->next = NULL,因为只有在p->next指向NULL时候，说明p有值p->next没有值，p->next赋值才是连续
            if(p->next == NULL)
                break;
            p = p->next;//为什么链表是连续指向下一个结构体，就是因为p = p->next指令；
        }
        p->next = new_init;
    }
    list->count++;//链表参数用于做判断；
}
//打印链表
void list_show(List_t *list)
{
    if(list->count == 0)
        return;
    Asc_t *p = list->head->next;
    while(1)
    {
        printf("%d\t",p->a);
        p = p->next;
        if(p == NULL)
            break;
    }
    printf("\n");
}

List_t *list_asc(List_t *listA , List_t *listB)
{
    List_t *listC = init();
    Asc_t *p1 = listA->head->next;
    Asc_t *p2 = listB->head->next;
	Asc_t *p3 = listC->head; //新链表的尾节点地址
  
	
    while(p1&&p2)
    {
        //p2小
        if((p1->a) > (p2->a))
        {
           p3->next = p2;
		   p2 = p2->next;
		   p3 = p3->next;
		   p3->next = NULL;
		   
		   printf("2\n"); 
        }
        else //P1 小
        {
            /* p3->a = p1->a;
            printf("p3->a=%d\n",p3->a);
            p1 = p1->next;
            p3 = p3->next; */
			
			
			p3->next = p1;
			
			p1 = p1->next;
			p3 = p3->next;
			p3->next = NULL;
			
            printf("1\n"); 
        } 
       
    }
	
	
	if(p1 != NULL){
		//p1有剩下的
		p3->next = p1;
        printf("p1\n");
	}
	else if(p2 != NULL){
		p3->next = p2;
	}
	
	 listC->count = listA->count + listB->count;
    return listC;
}
int main()
{
    List_t *listA = init();
    List_t *listB = init();
    

    list_insert_fail(listA , 2);
    list_insert_fail(listA , 8);
    list_insert_fail(listA , 15);
 

    list_insert_fail(listB , 3);
    list_insert_fail(listB , 5);
    list_insert_fail(listB , 9);

    list_show(listA);
    list_show(listB);
    
    List_t *listC = list_asc(listA , listB);

    list_show(listC);

    return 0;
}

